A code executing computing environment commonly referred to as system may include among other components an operating system, applications, and dynamically loaded libraries (DLLs) as are well known in the art. A number of functions commonly combined within standardized interfaces contribute to the system's overall behavior. To alter the behavior of a system functions such as for file input-output, prior art applications may reroute execution through well known hook functions or plainly called hooks. In a conventional hook, an application may invoke an original DLL function by utilizing the standardized interfaces.
Prior to and during code execution of an application, modifications are made to insert hooks between an application and DLL functions in order to allow for dynamic runtime changes to the application without source code modifications of applications and/or system. Hooks may pass execution to the original DLL function with same or alternated parameters and then return filtered or unfiltered results to the application after executing said DLL function. DLLs are continuously improved necessitating ongoing updating. Applications undergo an evolutionary process that may be independent of the related DLLs' evolution. To keep applications compatible with ever modifying systems, multiple versions of DLLs with identical name are kept accessible to applications. Unambiguous interaction between applications and identically named DLLs has been recently facilitated by technologies such as well known Microsoft Windows™ Side-by-side™ DLL loading. It causes even more identically named DLLs being loaded into isolated process memory area.
The inventor observed occasional and somewhat unpredictable failure of prior art hooks and discovered that such prior art hook failure was related to hooks directing execution to incorrect destination addresses when multiple versions of identically named DLLs were simultaneously loaded into well known isolated process memory areas. This is rooted in the fact that a particular application version may require functions embedded in distinct versions of an identically named DLL in order to execute in a predetermined manner inside a particular system version. In the case where updated versions of identically named functions having different functionality exist in several identically named DLLs, prior art hooks may eventually access and execute the wrong function. An error may result and/or may be detected only, if such ambiguously accessed functions differ in functionality to the extent, that the overlying application execution is adversely and/or noticeable effected. In praxis and at time this problem was discovered, occurrence may be estimated without claim for accuracy of less than one out of ten thousand implemented hooks. Irrespective such rare occurrence, this problem needs to be addressed for reliable implementation of hooks. Therefore, there exists a need for an improved hook function to be used with multiple target functions embedded in a number of identically named final destinations such as dynamically loaded libraries of distinct version. The present invention addresses this need.